package com.jingtao.product.service.impl;

import com.github.pagehelper.PageHelper;
import com.jingtao.product.dao.ProductCategoryAttributeRelationDao;
import com.jingtao.product.dao.ProductCategoryDao;
import com.jingtao.product.domain.DTO.ProductCategoryAttributeRelationExample;
import com.jingtao.product.domain.DTO.ProductCategoryDTO;
import com.jingtao.product.domain.DTO.ProductCategoryWithChildrenItem;
import com.jingtao.product.domain.DTO.ProductExample;
import com.jingtao.product.domain.Product;
import com.jingtao.product.domain.ProductCategory;
import com.jingtao.product.domain.ProductCategoryAttributeRelation;
import com.jingtao.product.domain.request.ProductCategoryParam;
import com.jingtao.product.domain.vo.ProductCategoryExample;
import com.jingtao.product.mapper.ProductCategoryAttributeRelationMapper;
import com.jingtao.product.mapper.ProductCategoryMapper;
import com.jingtao.product.mapper.ProductMapper;
import com.jingtao.product.service.ProductCategoryService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName:
 * @Description:
 * @Author: zengfanzhen
 * @Date: 2024/3/29 16:55:45
 */
@Service
public class ProductCategoryServiceImpl implements ProductCategoryService {

    @Autowired
    private ProductCategoryMapper productCategoryMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private ProductCategoryAttributeRelationDao productCategoryAttributeRelationDao;
    @Autowired
    private ProductCategoryAttributeRelationMapper productCategoryAttributeRelationMapper;
    @Autowired
    private ProductCategoryDao productCategoryDao;
    @Override
    public int create(ProductCategoryParam pmsProductCategoryParam) {
        ProductCategory productCategory = new ProductCategory();
        productCategory.setProductCount(0);
        BeanUtils.copyProperties(pmsProductCategoryParam, productCategory);
        //没有父分类时为一级分类
        setCategoryLevel(productCategory);
        int count = productCategoryMapper.insertSelective(productCategory);
        //创建筛选属性关联
        List<Long> productAttributeIdList = pmsProductCategoryParam.getProductAttributeIdList();
        if(!CollectionUtils.isEmpty(productAttributeIdList)){
            insertRelationList(productCategory.getId(), productAttributeIdList);
        }
        return count;
    }

    /**
     * 批量插入商品分类与筛选属性关系表
     * @param productCategoryId 商品分类id
     * @param productAttributeIdList 相关商品筛选属性id集合
     */
    private void insertRelationList(Long productCategoryId, List<Long> productAttributeIdList) {
        List<ProductCategoryAttributeRelation> relationList = new ArrayList<>();
        for (Long productAttrId : productAttributeIdList) {
            ProductCategoryAttributeRelation relation = new ProductCategoryAttributeRelation();
            relation.setProductAttributeId(productAttrId);
            relation.setProductCategoryId(productCategoryId);
            relationList.add(relation);
        }
        productCategoryAttributeRelationDao.insertList(relationList);
    }

    @Override
    public int update(Long id, ProductCategoryParam pmsProductCategoryParam) {
        ProductCategory productCategory = new ProductCategory();
        productCategory.setId(id);
        BeanUtils.copyProperties(pmsProductCategoryParam, productCategory);
        setCategoryLevel(productCategory);
        //更新商品分类时要更新商品中的名称
        Product product = new Product();
        product.setProductCategoryName(productCategory.getName());
        ProductExample example = new ProductExample();
        example.createCriteria().andProductCategoryIdEqualTo(id);
        productMapper.updateByExampleSelective(product,example);
        //同时更新筛选属性的信息
        if(!CollectionUtils.isEmpty(pmsProductCategoryParam.getProductAttributeIdList())){
            ProductCategoryAttributeRelationExample relationExample = new ProductCategoryAttributeRelationExample();
            relationExample.createCriteria().andProductCategoryIdEqualTo(id);
            productCategoryAttributeRelationMapper.deleteByExample(relationExample);
            insertRelationList(id,pmsProductCategoryParam.getProductAttributeIdList());
        }else{
            ProductCategoryAttributeRelationExample relationExample = new ProductCategoryAttributeRelationExample();
            relationExample.createCriteria().andProductCategoryIdEqualTo(id);
            productCategoryAttributeRelationMapper.deleteByExample(relationExample);
        }
        return productCategoryMapper.updateByPrimaryKeySelective(productCategory);
    }


    @Override
    public int delete(Long id) {
        return productCategoryMapper.deleteByPrimaryKey(id);
    }

    @Override
    public ProductCategory getItem(Long id) {
        return productCategoryMapper.selectByPrimaryKey(id);
    }

    @Override
    public int updateNavStatus(List<Long> ids, Integer navStatus) {
        ProductCategory productCategory = new ProductCategory();
        productCategory.setNavStatus(navStatus);
        ProductCategoryExample example = new ProductCategoryExample();
        example.createCriteria().andIdIn(ids);
        return productCategoryMapper.updateByExampleSelective(productCategory, example);
    }

    @Override
    public int updateShowStatus(List<Long> ids, Integer showStatus) {
        ProductCategory productCategory = new ProductCategory();
        productCategory.setShowStatus(showStatus);
        ProductCategoryExample example = new ProductCategoryExample();
        example.createCriteria().andIdIn(ids);
        return productCategoryMapper.updateByExampleSelective(productCategory, example);
    }

    /**
     * 根据分类的parentId设置分类的level
     */
    private void setCategoryLevel(ProductCategory productCategory) {
        //没有父分类时为一级分类
        if (productCategory.getParentId() == 0) {
            productCategory.setLevel(0);
        } else {
            //有父分类时选择根据父分类level设置
            ProductCategory parentCategory = productCategoryMapper.selectByPrimaryKey(productCategory.getParentId());
            if (parentCategory != null) {
                productCategory.setLevel(parentCategory.getLevel() + 1);
            } else {
                productCategory.setLevel(0);
            }
        }
    }

    /**
     * 获取产品类别列表。
     * @return 返回产品类别列表，列表中的每个元素都代表一个产品类别。
     */
    @Override
    public List<ProductCategory> getProductCategoryList() {
        return productCategoryMapper.getProductCategoryList();
    }


    /**
     * 获取所有产品类别及其子类别。
     * @return 返回所有产品类别及其子类别的列表。
     */
    @Override
    public List<ProductCategory> getAllProductCategoriesWithChildren(List<ProductCategory> parentCategories) {
        List<ProductCategory> result = new ArrayList<>();

        for (ProductCategory parentCategory : parentCategories) {
            result.add(parentCategory); // 添加当前分类

            List<ProductCategory> children = getProductCategoriesByParentId(parentCategory.getId());
            if (!children.isEmpty()) {
                List<ProductCategory> subCategories = getAllProductCategoriesWithChildren(children);
                result.addAll(subCategories);
            }
        }

        return result;
    }

    /**
     * 根据父分类 ID 查询子分类。
     * @param parentId 父分类 ID。
     * @return 返回子分类列表。
     */
    private List<ProductCategory> getProductCategoriesByParentId(Long parentId) {
        // 调用数据库查询方法，根据 parentId 查询子分类信息
        // 这里可以使用 MyBatis 或者其他 ORM 框架来执行查询
        // 返回查询结果
        return null;
    }



    @Override
    public List<ProductCategoryDTO> getAllCategories() {
        // 获取所有商品分类数据
        List<ProductCategoryDTO> allCategories = listSubCategories(0L);
        return allCategories;
    }

    /**
     * 递归查询子分类。
     * @param parentId 父分类 ID。
     * @return 返回子分类列表。
     */
    @Override
    public List<ProductCategoryDTO> listSubCategories(Long parentId) {
        // 递归查询子分类
        List<ProductCategoryDTO> subCategories = new ArrayList<>();
        List<ProductCategory> categories = productCategoryMapper.findByParentId(parentId);
        for (ProductCategory category : categories) {
            ProductCategoryDTO categoryDTO = new ProductCategoryDTO();
            BeanUtils.copyProperties(category, categoryDTO);
            categoryDTO.setSubCategories(listSubCategories(category.getId()));
            subCategories.add(categoryDTO);
        }
        return subCategories;
    }

    /**
     * 获取指定父级分类下的产品分类列表。
     * @param parentId 父级分类的ID，如果为null或0，则表示获取顶级分类。
     * @return 返回产品分类的列表，如果没有任何分类，则返回空列表。
     */
    @Override
    public List<ProductCategory> getList(Long parentId, Integer pageSize, Integer pageNum) {
        PageHelper.startPage(pageNum, pageSize);
        ProductCategoryExample example = new ProductCategoryExample();
        example.setOrderByClause("sort desc");
        example.createCriteria().andParentIdEqualTo(parentId);
        return productCategoryMapper.selectByExample(example);
    }

    @Override
    public List<ProductCategoryWithChildrenItem> listWithChildren() {
        return productCategoryDao.listWithChildren();
    }

}
